ast: record the brace on a hash literal (HashLit.Braced) - #42

Closes #40.

The gap

f({k: 1}) and f(k: 1) built structurally identical ast.HashLits. In Ruby 3+ they are different calls — a positional Hash and keywords — and ast.Call carries no position, so a consumer could not re-read the source to recover the brace either. Reproduction from the issue, against ruby 4.0.5:

def f(*a, **k) = [a, k]
p f({x: 1})   # MRI [[{x: 1}], {}]   consumer [[], {x: 1}]   <- diverges
p f(x: 1)     # MRI [[], {x: 1}]     consumer [[], {x: 1}]
h = {y: 2}
p f(h)        # MRI [[{y: 2}], {}]   consumer [[{y: 2}], {}]  <- a VARIABLE is fine

Only the braced literal at a call site diverges, which is what a missing bit predicts.

The grammar says to record it here

MRI carries this exact bit, in this exact place, and I followed it rather than inventing a shape:

So parseHashLiteral sets Braced and addKwPair does not — one line each, mirroring MRI one to one.

The bit says only "written with braces", and is deliberately not conditional on being an argument, again as in MRI: x = {a: 1} is Braced too. A consumer asking "positional Hash argument?" asks Braced of a node it already found in Call.Args. Making the parser guess the call-site condition would put the consumer's question into the parser.

The bit takes both values

Measured by the tests added here. Braced is neither always true nor always false, and the two spellings that must differ do differ:

obj.m {} is where a careless rule breaks the language, and ours cannot: a { after a call never reaches parseHashLiteral, structurally the same defence as MRI's lexer deciding before the grammar sees it. There is no HashLit there to mislabel, and a test asserts that.

Negative control: with Braced: true reverted to &ast.HashLit{}, 11 assertions in the new tests fail. The tests measure the change rather than passing alongside it.

Existing consumers are unaffected

• No existing test was changed. git diff --name-only origin/main is ast/ast.go and parser.go only; the one new file is hash_braced_test.go.
• Full suite green before and after (parser, ast, lexer, token), go vet ./... clean, gofmt -l clean on both changed files.
• gofmt -l . does report paren_singleton_def_test.go — that is pre-existing on main (verified by formatting a pristine copy of origin/main:paren_singleton_def_test.go) and untouched here, so I left it rather than pad this diff.

The zero value is false, so anyone who does not read the field sees nothing.

Why this is a separate PR from #41

The two changes share no code: different structs, disjoint parser sites, no common helper. They are the same idea — one bit of written form, with RangeLit.Exclusive as precedent — but nothing would be reused by merging them, and split they can be reviewed and merged independently. See #41's PR for the other half.

What the consumer will need (separately)

Not in this PR. go-embedded-ruby/ruby needs a released parser version first, and a sibling wave is working there. When it picks this up: at a call site, a trailing *ast.HashLit argument with Braced == true is a positional argument and must not be spliced into keywords; only Braced == false is the keyword hash. f({}) must pass an empty positional Hash where f() passes nothing.

🤖 Generated with Claude Code